The OPC Binary XML Schema defines the format of OPC Binary TypeDictionaries. Each OPC Binary TypeDictionary is an XML document that contains one or more TypeDescriptions that describe the format of a binary-encoded value. Applications that have no advanced knowledge of a particular binary encoding can use the OPC Binary TypeDescription to interpret or construct a value.

The OPC Binary Type Description System does not define a standard mechanism to encode data in binary. It only provides a standard way to describe an existing binary encoding. Many binary encodings will have a mechanism to describe types that could be encoded; however, these descriptions are useful only to applications that have knowledge of the type description system used with each binary encoding. The OPC Binary Type Description System is a generic syntax that can be used by any application to interpret any binary encoding.

The OPC Binary Type Description System was originally defined in the OPC Complex Data Specification. The OPC Binary Type Description System described in Annex C is quite different and is correctly described as the OPC Binary Type Description System Version 2.0.

Each TypeDescription is identified by a TypeName which shall be unique within the TypeDictionary that defines it. Each TypeDictionary also has a TargetNamespace which should be unique among all OPC Binary TypeDictionaries. This means that the TypeName qualified with the TargetNamespace for the dictionary should be a globally-unique identifier for a TypeDescription.

Figure C.1 illustrates the structure of an OPC Binary TypeDictionary.

Figure C.1 – OPC Binary Dictionary structure

Each binary encoding is built from a set of opaque building blocks that are either primitive types with a fixed length or variable-length types with a structure that is too complex to describe properly in an XML document. These building blocks are described with an OpaqueType. An instance of one of these building blocks is a binary-encoded value.

The OPC Binary Type Description System defines a set of standard OpaqueTypes that all OPC Binary TypeDictionaries should use to build their TypeDescriptions. These standard type descriptions are described in Clause C.3.

In some cases, the binary encoding described by an OpaqueType may have a fixed size which would allow an application to skip an encoded value that it does not understand. If that is the case, then the LengthInBits attribute should be specified for the OpaqueType. If authors of TypeDictionaries need to define new OpaqueTypes that do not have a fixed size then they should use the documentation elements to describe how to encode binary values for the type. This description should provide enough detail to allow a human to write a program that can interpret instances of the type.

A StructuredType breaks a complex value into a sequence of values that are described by a FieldType. Each FieldType has a name, type and a number of qualifiers that specify when the field is used and how many instances of the type exist. A FieldType is described completely in C.2.6.

An EnumeratedType describes a numeric value that has a limited set of possible values, each of which has a descriptive name. EnumeratedTypes provide a convenient way to capture semantic information associated with what would otherwise be an opaque numeric value.

The TypeDictionary element is the root element of an OPC Binary Dictionary. The components of this element are described in Table C.1.

Table C.1 – TypeDictionary components

Name	Type	Description
Documentation	Documentation	An element that contains human-readable text and XML that provides an overview of what is contained in the dictionary.
Import	ImportDirective[]	Zero or more elements that specify other TypeDictionaries that are referenced by StructuredTypes defined in the dictionary. Each import element specifies the NamespaceUri of the TypeDictionary being imported. The TypeDictionary element shall declare an XML namespace prefix for each imported namespace.
TargetNamespace	xs:string	Specifies the URI that qualifies all TypeDescriptions defined in the dictionary.
DefaultByteOrder	ByteOrder	Specifies the default ByteOrder for all TypeDescriptions that have the ByteOrderSignificant attribute set to "true". This value overrides the setting in any imported TypeDictionary. This value is overridden by the DefaultByteOrder specified on a TypeDescription.
TypeDescription	TypeDescription[]	One or more elements that describe the structure of a binary encoded value. A TypeDescription is an abstract type. A dictionary may only contain the OpaqueType, EnumeratedType and StructuredType elements.

A TypeDescription describes the structure of a binary encoded value. A TypeDescription is an abstract base type and only instances of subtypes may appear in a TypeDictionary. The components of a TypeDescription are described in Table C.2.

Table C.2 – TypeDescription components

Name	Type	Description
Documentation	Documentation	An element that contains human readable text and XML that describes the type. This element should capture any semantic information that would help a human to understand what is contained in the value.
Name	xs:NCName	An attribute that specifies a name for the TypeDescription that is unique within the dictionary. The fields of structured types reference TypeDescriptions by using this name qualified with the dictionary namespace URI.
DefaultByteOrder	ByteOrder	An attribute that specifies the default ByteOrder for the type description. This value overrides the setting in any TypeDictionary or in any StructuredType that references the type description.
anyAttribute	*	Authors of a TypeDictionary may add their own attributes to any TypeDescription that shall be qualified with a namespace defined by the author. Applications should not be required to understand these attributes in order to interpret a binary encoded instance of the type.

An OpaqueType describes a binary encoded value that is either a primitive fixed length type or that has a structure too complex to capture in an OPC Binary type dictionary. Authors of type dictionaries should avoid defining OpaqueTypes that do not have a fixed length because it would prevent applications from interpreting values that use these types without having built-in knowledge of the OpaqueType. The OPC Binary Type Description System defines many standard OpaqueTypes that should allow authors to describe most binary encoded values as StructuredTypes.

The components of an OpaqueType are described in Table C.3.

Table C.3 – OpaqueType components

Name	Type	Description
TypeDescription	TypeDescription	An OpaqueType inherits all elements and attributes defined for a TypeDescription in Table C.2.
LengthInBits	xs:string	An attribute which specifies the length of the OpaqueType in bits. This value should always be specified. If this value is not specified the Documentation element should describe the encoding in a way that a human understands.
ByteOrderSignificant	xs:boolean	An attribute that indicates whether byte order is significant for the type. If byte order is significant then the application shall determine the byte order to use for the current context before interpreting the encoded value. The application determines the byte order by looking for the DefaultByteOrder attribute specified for containing StructuredTypes or the TypeDictionary. If StructuredTypes are nested the inner StructuredTypes override the byte order of the outer descriptions. If the DefaultByteOrder attribute is specified for the OpaqueType, then the ByteOrder is fixed and does not change according to context. If this attribute is "true", then the LengthInBits attribute shall be specified and it shall be an integer multiple of 8 bits.

An EnumeratedType describes a binary-encoded numeric value that has a fixed set of valid values. The encoded binary value described by an EnumeratedType is always an unsigned integer with a length specified by the LengthInBits attribute.

The names for each of the enumerated values are not required to interpret the binary encoding, however, they form part of the documentation for the type.

The components of an EnumeratedType are described in Table C.4.

Table C.4 – EnumeratedType components

Name	Type	Description
OpaqueType	OpaqueTypeDescription	An EnumeratedType inherits all elements and attributes defined for a TypeDescription in Table C.2 and for an OpaqueType defined in Table C.3. The LengthInBits attribute shall always be specified.
EnumeratedValue	EnumeratedValue	One or more elements that describe the possible values for the instances of the type.
IsOptionSet	xs:boolean	An attribute which when set to ‘true’ indicates an EnumeratedType represents an OptionSet.

A StructuredType describes a type as a sequence of binary-encoded values. Each value in the sequence is called a Field. Each Field references a TypeDescription that describes the binary-encoded value that appears in the field. A Field may specify that zero, one or multiple instances of the type appear within the sequence described by the StructuredType.

Authors of type dictionaries should use StructuredTypes to describe a variety of common data constructs including arrays, unions and structures.

Some fields have lengths that are not multiples of 8 bits. Several of these fields may appear in a sequence in a structure, however, the total number of bits used in the sequence shall be fixed and it shall be a multiple of 8 bits. Any field which does not have a fixed length shall be aligned on a byte boundary.

A sequence of fields which do not line up on byte boundaries are specified from the least significant bit to the most significant bit. Sequences which are longer than one byte overflow from the most significant bit of the first byte into the least significant bit of the next byte.

The components of a StructuredType are described in Table C.5.

Table C.5 – StructuredType components

Name	Type	Description
TypeDescription	TypeDescription	A StructuredType inherits all elements and attributes defined for a TypeDescription in Table C.2.
Field	FieldType	One or more elements that describe the fields of the structure. Each field shall have a name that is unique within the StructuredType. Some fields may reference other fields in the StructuredType by using this name.

A FieldType describes a binary encoded value that appears in sequence within a StructuredType. Every FieldType shall reference a TypeDescription that describes the encoded value for the field.

A FieldType may specify an array of encoded values.

Fields may be optional and they reference other FieldTypes, which indicate if they are present in any specific instance of the type.

The components of a FieldType are described in Table C.6.

Table C.6 – FieldType components

Name	Type	Description
Documentation	Documentation	An element that contains human readable text and XML that describes the field. This element should capture any semantic information that would help a human to understand what is contained in the field.
Name	xs:string	An attribute that specifies a name for the Field that is unique within the StructuredType. Other fields in the structured type reference a Field by using this name.
TypeName	xs:QName	An attribute that specifies the TypeDescription that describes the contents of the field. A field may contain zero or more instances of this type depending on the settings for the other attributes and the values in other fields.
Length	xs:unsignedInt	An attribute that indicates the length of the field. This value may be the total number of encoded bytes or it may be the number of instances of the type referenced by the field. The IsLengthInBytes attributes specifies which of these definitions applies.
LengthField	xs:string	An attribute that indicates which other field in the StructuredType specifies the length of the field. The length of the field may be in bytes or it may be the number of instances of the type referenced by the field. The IsLengthInBytes attributes specify which of these definitions applies. If this attribute refers to a field that is not present in an encoded value, then the default value for the length is 1. This situation could occur if the field referenced is an optional field (see the SwitchField attribute). The length field shall be a fixed length Base-2 representation of an integer. If the length field is one of the standard signed integer types and the value is a negative integer, then the field is not present in the encoded stream. The FieldType referenced by this attribute shall precede the field with the StructuredType.
IsLengthInBytes	xs:boolean	An attribute that indicates whether the Length or LengthField attributes specify the length of the field in bytes or in the number of instances of the type referenced by the field.
SwitchField	xs:string	If this attribute is specified, then the field is optional and may not appear in every instance of the encoded value. This attribute specifies the name of another Field that controls whether this field is present in the encoded value. The field referenced by this attribute shall be an integer value (see the LengthField attribute). The current value of the switch field is compared to the SwitchValue attribute using the SwitchOperand. If the condition evaluates to true then the field appears in the stream. If the SwitchValue attribute is not specified, then this field is present if the value of the switch field is non-zero. The SwitchOperand field is ignored if it is present. If the SwitchOperand attribute is missing, then the field is present if the value of the switch field is equal to the value of the SwitchValue attribute. The Field referenced by this attribute shall precede the field with the StructuredType.
SwitchValue	xs:unsignedInt	This attribute specifies when the field appears in the encoded value. The value of the field referenced by the SwitchField attribute is compared using the SwitchOperand attribute to this value. The field is present if the expression evaluates to true. The field is not present otherwise.
SwitchOperand	xs:string	This attribute specifies how the value of the switch field should be compared to the switch value attribute. This field is an enumeration with the following values: Equal SwitchField is equal to the SwitchValue. GreaterThan SwitchField is greater than the SwitchValue. LessThan SwitchField is less than the SwitchValue. GreaterThanOrEqual SwitchField is greater than or equal to the SwitchValue. LessThanOrEqual SwitchField is less than or equal to the SwitchValue. NotEqual SwitchField is not equal to the SwitchValue. In each case the field is present if the expression is true.
Terminator	xs:hexBinary	This attribute indicates that the field contains one or more instances of TypeDescription referenced by this field and that the last value has the binary encoding specified by the value of this attribute. If this attribute is specified then the TypeDescription referenced by this field shall either have a fixed byte order (i.e. byte order is not significant or explicitly specified) or the containing StructuredType shall explicitly specify the byte order. Examples: Field Data TypeTerminatorByte OrderHexadecimal String Char tab characternot applicable09 WideChartab characterBigEndian0009 WideChartab characterLittleEndian0900 Int16 1 BigEndian0001 Int16 1 LittleEndian0100
anyAttribute	*	Authors of a TypeDictionary may add their own attributes to any FieldType which shall be qualified with a namespace defined by the authors. Applications should not be required to understand these attributes in order to interpret a binary encoded field value.

An EnumeratedValue describes a possible value for an EnumeratedType.

The components of an EnumeratedValue are described in Table C.7.

Table C.7 – EnumeratedValue components

Name	Type	Description
Name	xs:string	This attribute specifies a descriptive name for the enumerated value.
Value	xs:int	This attribute specifies the numeric value that could appear in the binary encoding.

A ByteOrder is an enumeration that describes a possible value byte orders for TypeDescriptions that allow different byte orders to be used. There are two possible values: BigEndian and LittleEndian. BigEndian indicates the most significant byte appears first in the binary encoding. LittleEndian indicates that the least significant byte appears first.

An ImportDirective specifies a TypeDictionary that is referenced by types defined in the current dictionary.

The components of an ImportDirective are described in Table C.8.

Table C.8 – ImportDirective components

Name	Type	Description
Namespace	xs:string	This attribute specifies the TargetNamespace for the TypeDictionary being imported. This may be a well-known URI which means applications need not have access to the physical file to recognise types that are referenced.
Location	xs:string	This attribute specifies the physical location of the XML file containing the TypeDictionary to import. This value could be a URL for a network resource, a NodeId in an OPC UA Server address space or a local file path.

The OPC Binary Type Description System defines a number of standard type descriptions that can be used to describe many common binary encodings using a StructuredType. The standard type descriptions are described in Table C.9.

Table C.9 – Standard Type descriptions

Type name	Description
Bit	A single bit value.
Boolean	A two-state logical value represented as an 8-bit value.
SByte	An 8-bit signed integer.
Byte	An 8-bit unsigned integer.
Int16	A 16-bit signed integer.
UInt16	A 16-bit unsigned integer.
Int32	A 32-bit signed integer.
UInt32	A 32-bit unsigned integer.
Int64	A 64-bit signed integer.
UInt64	A 64-bit unsigned integer.
Float	An ISO/IEC/IEEE 60559: single precision floating point value.
Double	An ISO/IEC/IEEE 60559: double precision floating point value.
Char	An 8-bit UTF-8 character value.
String	A sequence of UTF-8 characters preceded by the number of UTF-8 Code Units (bytes).
WideString	A sequence of UTF-16 characters preceded by the number of UTF-16 Code Units.
DateTime	A 64-bit signed integer representing the number of 100 nanoseconds intervals since 1601-01-01 00:00:00.
ByteString	A sequence of bytes preceded by its length in bytes.
Guid	An ISO/IEC 11578:1996: Information technology — Open Systems Interconnection — Remote Procedure Call (RPC) UUID.

1. A 128-bit signed integer.

<opc:OpaqueType Name="Int128" LengthInBits="128" ByteOrderSignificant="true">

<opc:Documentation>A 128-bit signed integer.</opc:Documentation>

</opc:OpaqueType>

1. A 16-bit value divided into several fields.

<opc:StructuredType Name="Quality">

<opc:Documentation>An OPC COM-DA quality value.</opc:Documentation>

<opc:Field Name="LimitBits" TypeName="opc:Bit" Length="2" />

<opc:Field Name="QualityBits" TypeName="opc:Bit" Length="6"/>

<opc:Field Name="VendorBits" TypeName="opc:Byte" />

</opc:StructuredType>

When using bit fields, the least significant bits within a byte shall appear first.

1. A structured type with optional fields.

<opc:StructuredType Name="MyStructureValue">

<opc:Documentation>A value with an associated timestamp, and quality.</opc:Documentation>

<opc:Field Name="ValueSpecified" TypeName="Bit" />

<opc:Field Name="StatusCodeSpecified" TypeName="Bit" />

<opc:Field Name="TimestampSpecified" TypeName="Bit" />

<opc:Field Name="Reserved1" TypeName="Bit" Length="29" />

<opc:Field Name="Value" TypeName="Variant" SwitchField="ValueSpecified" />

<opc:Field Name="Quality" TypeName="Quality" SwitchField="StatusCodeSpecified" />

<opc:Field Name="Timestamp"

TypeName="opc:DateTime" SwitchField="SourceTimestampSpecified" />

</opc:StructuredType>

It is necessary to explicitly specify any padding bits required to ensure subsequent fields line up on byte boundaries.

1. An array of integers.

<opc:StructuredType Name="IntegerArray">

<opc:Documentation>An array of integers prefixed by its length.</opc:Documentation>

<opc:Field Name="Size" TypeName="opc:Int32" />

<opc:Field Name="Array" TypeName="opc:Int32" LengthField="Size" />

</opc:StructuredType>

Nothing is encoded for the Array field if the Size field has a value ≤ 0.

1. An array of integers with a terminator instead of a length prefix.

<opc:StructuredType Name="IntegerArray" DefaultByteOrder="LittleEndian">

<opc:Documentation>An array of integers terminated with a known value.</opc:Documentation>

<opc:Field Name="Value" TypeName="opc:Int16" Terminator="FF7F" />

</opc:StructuredType>

The terminator is 32,767 converted to hexadecimal with LittleEndian byte order.

1. A simple union.

<opc:StructuredType Name="Variant">

<opc:Documentation>A union of several types.</opc:Documentation>

<opc:Field Name="ArrayLengthSpecified" TypeName="opc:Bit" Length="1"/>

<opc:Field Name="VariantType" TypeName="opc:Bit" Length="7" />

<opc:Field Name="ArrayLength" TypeName="opc:Int32"

SwitchField="ArrayLengthSpecified" />

<opc:Field Name="Int32" TypeName="opc:Int32" LengthField="ArrayLength"

SwitchField="VariantType" SwitchValue="1" />

<opc:Field Name="String" TypeName="opc:String" LengthField="ArrayLength"

SwitchField="VariantType" SwitchValue="2" />

<opc:Field Name="DateTime" TypeName="opc:DateTime" LengthField="ArrayLength"

SwitchField="VariantType" SwitchValue="3" />

</opc:StructuredType>

The ArrayLength field is optional. If it is not present in an encoded value, then the length of all fields with LengthField set to "ArrayLength" have a length of 1.

It is valid for the VariantType field to have a value that has no matching field defined. This simply means all optional fields are not present in the encoded value.

1. An enumerated type.

<opc:EnumeratedType Name="TrafficLight" LengthInBits="32">

<opc:Documentation>The possible colours for a traffic signal.</opc:Documentation>

<opc:EnumeratedValue Name="Red" Value="4">

<opc:Documentation>Red says stop immediately.</opc:Documentation>

</opc:EnumeratedValue>

<opc:EnumeratedValue Name="Yellow" Value="3">

<opc:Documentation>Yellow says prepare to stop.</opc:Documentation>

</opc:EnumeratedValue>

<opc:EnumeratedValue Name="Green" Value="2">

<opc:Documentation>Green says you may proceed.</opc:Documentation>

</opc:EnumeratedValue>

</opc:EnumeratedType>

The documentation element is used to provide human readable description of the type and values.

1. A nillable array.

<opc:StructuredTypen Name="NillableArray">

<opc:Documentation>An array where a length of -1 means null.</opc:Documentation>

<opc:Field Name="Length" TypeName="opc:Int32" />

<opc:Field

Name="Int32"

TypeName="opc:Int32"

LengthField="Length"

SwitchField="Length"

SwitchValue="0"

SwitchOperand="GreaterThanOrEqual" />

</opc:StructuredType>

If the length of the array is −1 then the array does not appear in the stream.

<?xml version="1.0" encoding="utf-8" ?>

<xs:schema

targetNamespace="http://opcfoundation.org/BinarySchema/"

elementFormDefault="qualified"

xmlns="http://opcfoundation.org/BinarySchema/"

xmlns:xs="http://www.w3.org/2001/XMLSchema"

>

<xs:element name="Documentation">

<xs:complexType mixed="true">

<xs:choice minOccurs="0" maxOccurs="unbounded">

<xs:any minOccurs="0" maxOccurs="unbounded"/>

</xs:choice>

<xs:anyAttribute/>

</xs:complexType>

</xs:element>

<xs:complexType name="ImportDirective">

<xs:attribute name="Namespace" type="xs:string" use="optional" />

<xs:attribute name="Location" type="xs:string" use="optional" />

</xs:complexType>

<xs:simpleType name="ByteOrder">

<xs:restriction base="xs:string">

<xs:enumeration value="BigEndian" />

<xs:enumeration value="LittleEndian" />

</xs:restriction>

</xs:simpleType>

<xs:complexType name="TypeDescription">

<xs:sequence>

<xs:element ref="Documentation" minOccurs="0" maxOccurs="1" />

</xs:sequence>

<xs:attribute name="Name" type="xs:NCName" use="required" />

<xs:attribute name="DefaultByteOrder" type="ByteOrder" use="optional" />

<xs:anyAttribute processContents="lax" />

</xs:complexType>

<xs:complexType name="OpaqueType">

<xs:complexContent>

<xs:extension base="TypeDescription">

<xs:attribute name="LengthInBits" type="xs:int" use="optional" />

<xs:attribute name="ByteOrderSignificant" type="xs:boolean" default="false" />

</xs:extension>

</xs:complexContent>

</xs:complexType>

<xs:complexType name="EnumeratedValue">

<xs:sequence>

<xs:element ref="Documentation" minOccurs="0" maxOccurs="1" />

</xs:sequence>

<xs:attribute name="Name" type="xs:string" use="optional" />

<xs:attribute name="Value" type="xs:unsignedInt" use="optional" />

</xs:complexType>

<xs:complexType name="EnumeratedType">

<xs:complexContent>

<xs:extension base="OpaqueTypeDescription">

<xs:sequence>

<xs:element name="EnumeratedValue"

type="EnumeratedValueDescription" maxOccurs="unbounded" />

</xs:sequence>

</xs:extension>

</xs:complexContent>

</xs:complexType>

<xs:simpleType name="SwitchOperand">

<xs:restriction base="xs:string">

<xs:enumeration value="Equals" />

<xs:enumeration value="GreaterThan" />

<xs:enumeration value="LessThan" />

<xs:enumeration value="GreaterThanOrEqual" />

<xs:enumeration value="LessThanOrEqual" />

<xs:enumeration value="NotEqual" />

</xs:restriction>

</xs:simpleType>

<xs:complexType name="FieldType">

<xs:sequence>

<xs:element ref="Documentation" minOccurs="0" maxOccurs="1" />

</xs:sequence>

<xs:attribute name="Name" type="xs:string" use="required" />

<xs:attribute name="TypeName" type="xs:QName" use="optional" />

<xs:attribute name="Length" type="xs:unsignedInt" use="optional" />

<xs:attribute name="LengthField" type="xs:string" use="optional" />

<xs:attribute name="IsLengthInBytes" type="xs:boolean" default="false" />

<xs:attribute name="SwitchField" type="xs:string" use="optional" />

<xs:attribute name="SwitchValue" type="xs:unsignedInt" use="optional" />

<xs:attribute name="SwitchOperand" type="SwitchOperand" use="optional" />

<xs:attribute name="Terminator" type="xs:hexBinary" use="optional" />

<xs:anyAttribute processContents="lax" />

</xs:complexType>

<xs:complexType name="StructuredType">

<xs:complexContent>

<xs:extension base="TypeDescription">

<xs:sequence>

<xs:element name="Field" type="FieldType"

minOccurs="0" maxOccurs="unbounded" />

</xs:sequence>

</xs:extension>

</xs:complexContent>

</xs:complexType>

<xs:element name="TypeDictionary">

<xs:complexType>

<xs:sequence>

<xs:element ref="Documentation" minOccurs="0" maxOccurs="1" />

<xs:element name="Import" type="ImportDirective"

minOccurs="0" maxOccurs="unbounded" />

<xs:choice minOccurs="0" maxOccurs="unbounded">

<xs:element name="OpaqueType" type="OpaqueType" />

<xs:element name="EnumeratedType" type="EnumeratedType" />

<xs:element name="StructuredType" type="StructuredType" />

</xs:choice>

</xs:sequence>

<xs:attribute name="TargetNamespace" type="xs:string" use="required" />

<xs:attribute name="DefaultByteOrder" type="ByteOrder" use="optional" />

</xs:complexType>

</xs:element>

</xs:schema>

<?xml version="1.0" encoding="utf-8"?>

<opc:TypeDictionary

xmlns="http://opcfoundation.org/BinarySchema/"

xmlns:opc="http://opcfoundation.org/BinarySchema/"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

TargetNamespace="http://opcfoundation.org/BinarySchema/"

>

<opc:Documentation>This dictionary defines the standard types used by the OPC Binary type description system.</opc:Documentation>

<opc:OpaqueType Name="Bit" LengthInBits="1">

<opc:Documentation>A single bit.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="Boolean" LengthInBits="8">

<opc:Documentation>A two state logical value represented as a 8-bit value.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="SByte" LengthInBits="8">

<opc:Documentation>An 8-bit signed integer.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="Byte" LengthInBits="8">

<opc:Documentation>A 8-bit unsigned integer.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="Int16" LengthInBits="16" ByteOrderSignificant="true">

<opc:Documentation>A 16-bit signed integer.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="UInt16" LengthInBits="16" ByteOrderSignificant="true">

<opc:Documentation>A 16-bit unsigned integer.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="Int32" LengthInBits="32" ByteOrderSignificant="true">

<opc:Documentation>A 32-bit signed integer.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="UInt32" LengthInBits="32" ByteOrderSignificant="true">

<opc:Documentation>A 32-bit unsigned integer.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="Int64" LengthInBits="32" ByteOrderSignificant="true">

<opc:Documentation>A 64-bit signed integer.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="UInt64" LengthInBits="64" ByteOrderSignificant="true">

<opc:Documentation>A 64-bit unsigned integer.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="Float" LengthInBits="32" ByteOrderSignificant="true">

<opc:Documentation>An IEEE-754 single precision floating point value.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="Double" LengthInBits="64" ByteOrderSignificant="true">

<opc:Documentation>An IEEE-754 double precision floating point value.</opc:Documentation>

</opc:OpaqueType>

<opc:OpaqueType Name="Char" LengthInBits="8">

<opc:Documentation>A 8-bit character value.</opc:Documentation>

</opc:OpaqueType>

<opc:StructuredType Name="String">

<opc:Documentation>A UTF-8 null terminated string value.</opc:Documentation>

<opc:Field Name="Value" TypeName="Char" Terminator="00" />

</opc:StructuredType>

<opc:StructuredType Name="CharArray">

<opc:Documentation>A UTF-8 string prefixed by its length in characters.</opc:Documentation>

<opc:Field Name="Length" TypeName="Int32" />

<opc:Field Name="Value" TypeName="Char" LengthField="Length" />

</opc:StructuredType>

<opc:OpaqueType Name="WideChar" LengthInBits="16" ByteOrderSignificant="true">

<opc:Documentation>A 16-bit character value.</opc:Documentation>

</opc:OpaqueType>

<opc:StructuredType Name="WideString">

<opc:Documentation>A UTF-16 null terminated string value.</opc:Documentation>

<opc:Field Name="Value" TypeName="WideChar" Terminator="0000" />

</opc:StructuredType>

<opc:StructuredType Name="WideCharArray">

<opc:Documentation>A UTF-16 string prefixed by its length in characters.</opc:Documentation>

<opc:Field Name="Length" TypeName="Int32" />

<opc:Field Name="Value" TypeName="WideChar" LengthField="Length" />

</opc:StructuredType>

<opc:StructuredType Name="ByteString">

<opc:Documentation>An array of bytes prefixed by its length.</opc:Documentation>

<opc:Field Name="Length" TypeName="Int32" />

<opc:Field Name="Value" TypeName="Byte" LengthField="Length" />

</opc:StructuredType>

<opc:OpaqueType Name="DateTime" LengthInBits="64" ByteOrderSignificant="true">

<opc:Documentation>The number of 100 nanosecond intervals since January 01, 1601.</opc:Documentation>

</opc:OpaqueType>

<opc:StructuredType Name="Guid">

<opc:Documentation>A 128-bit globally unique identifier.</opc:Documentation>

<opc:Field Name="Data1" TypeName="UInt32" />

<opc:Field Name="Data2" TypeName="UInt16" />

<opc:Field Name="Data3" TypeName="UInt16" />

<opc:Field Name="Data4" TypeName="Byte" Length="8" />

</opc:StructuredType>

</opc:TypeDictionary>